home *** CD-ROM | disk | FTP | other *** search
/ Deutsche Edition 1 / Deutsche Edition 1.iso / amok / amok_lha / amok72.lha / while-Interpreter / Source / QuadBerechneQuad.MOD < prev    next >
Text File  |  1993-08-15  |  7KB  |  218 lines
  1. (******************************
  2.  * Programm von Dieter Seidel *
  3.  *  Eingegeben am 14.11.1991  *
  4.  ******************************)
  5.  
  6.  
  7. IMPLEMENTATION MODULE QuadBerechneQuad;
  8.  
  9. FROM InOut           IMPORT WriteCard, WriteLn, Write, WriteString;
  10. FROM QuadLese        IMPORT MaxBefehle, MaxQuad, MaxZeile, WhileBegin,
  11.                             arrZeile, QuadZeile, arrQuad, arrList;
  12. FROM QuadHoleBefehle IMPORT HoleZuweisung, HoleSchleife, HoleUnterprogramm;
  13.  
  14.  
  15. PROCEDURE BerechneQuad(    BefehlsListe : arrList;
  16.                        VAR QuadListe    : arrQuad);
  17. VAR Zaehler,
  18.     Zeiger,
  19.     Counter,
  20.     Counter2,
  21.     begin   : CARDINAL;
  22.     Korrekt : BOOLEAN;
  23.     array   : ARRAY [1..MaxBefehle] OF WhileBegin;
  24. BEGIN
  25.   begin:=0;
  26.   Zaehler:=1;
  27.   Zeiger:=1;
  28.  
  29.   REPEAT
  30.     Korrekt:=FALSE;
  31.  
  32.     IF (Zaehler > MaxQuad) THEN
  33.       WriteLn;
  34.       WriteString("Fehler : Erhoehe MaxQuad!!!");
  35.       WriteLn;
  36.       HALT;
  37.     END;
  38.  
  39.     IF ((Zeiger+10) > MaxBefehle) THEN
  40.       WriteLn;
  41.       WriteString("Fehler : Erhoehe MaxBefehle!!!");
  42.       WriteLn;
  43.       HALT;
  44.     END;
  45.  
  46.     IF (BefehlsListe[Zeiger] = "b") AND NOT(Korrekt) THEN
  47.       IF Zaehler > 1 THEN
  48.         IF array[Zaehler-1].while THEN
  49.           array[Zaehler-1].begin:=TRUE;
  50.         ELSE
  51.           WriteLn;
  52.           WriteString("Fehler : kein while-begin gefunden!!!");
  53.           WriteLn;
  54.           HALT;
  55.         END;
  56.       END;
  57.       INC(begin);
  58.       INC(Zeiger);
  59.       Korrekt:=TRUE;
  60.     END;
  61.  
  62.     IF (BefehlsListe[Zeiger] = "X") AND NOT(Korrekt) THEN
  63.       HoleZuweisung(QuadListe[Zaehler].Befehl,BefehlsListe,Zeiger);
  64.       QuadListe[Zaehler].Zeile:=Zaehler;
  65.       QuadListe[Zaehler].IFzeile:=Zaehler+1;
  66.       QuadListe[Zaehler].ELSEzeile:=Zaehler+1;
  67.       IF Zaehler > 1 THEN
  68.         IF array[Zaehler-1].while AND NOT(array[Zaehler-1].begin) THEN
  69.           QuadListe[Zaehler].IFzeile:=Zaehler-1;
  70.           QuadListe[Zaehler].ELSEzeile:=Zaehler-1;
  71.           Counter:=Zaehler-1;
  72.           WHILE (Counter >= 1) AND (array[Counter].while) AND
  73.                  NOT(array[Counter].begin) DO
  74.             DEC(Counter);
  75.           END;
  76.           INC(Counter);
  77.           QuadListe[Counter].IFzeile:=Counter+1;
  78.           QuadListe[Counter].ELSEzeile:=Zaehler+1;
  79.           INC(Counter);
  80.           WHILE Counter < Zaehler DO
  81.             QuadListe[Counter].IFzeile:=Counter+1;
  82.             QuadListe[Counter].ELSEzeile:=Counter-1;
  83.             INC(Counter);
  84.           END;
  85.         END;
  86.       END;
  87.       array[Zaehler].while:=FALSE;
  88.       array[Zaehler].begin:=FALSE;
  89.       INC(Zaehler);
  90.       Korrekt:=TRUE;
  91.     END;
  92.  
  93.     IF (BefehlsListe[Zeiger] = "U") AND NOT(Korrekt) THEN
  94.       HoleUnterprogramm(QuadListe[Zaehler].Befehl,BefehlsListe,Zeiger);
  95.       QuadListe[Zaehler].Zeile:=Zaehler;
  96.       QuadListe[Zaehler].IFzeile:=Zaehler+1;
  97.       QuadListe[Zaehler].ELSEzeile:=Zaehler+1;
  98.       IF Zaehler > 1 THEN
  99.         IF array[Zaehler-1].while AND NOT(array[Zaehler-1].begin) THEN
  100.           QuadListe[Zaehler].IFzeile:=Zaehler-1;
  101.           QuadListe[Zaehler].ELSEzeile:=Zaehler-1;
  102.           Counter:=Zaehler-1;
  103.           WHILE (Counter >= 1) AND (array[Counter].while) AND
  104.                  NOT(array[Counter].begin) DO
  105.             DEC(Counter);
  106.           END;
  107.           INC(Counter);
  108.           QuadListe[Counter].IFzeile:=Counter+1;
  109.           QuadListe[Counter].ELSEzeile:=Zaehler+1;
  110.           INC(Counter);
  111.           WHILE Counter < Zaehler DO
  112.             QuadListe[Counter].IFzeile:=Counter+1;
  113.             QuadListe[Counter].ELSEzeile:=Counter-1;
  114.             INC(Counter);
  115.           END;
  116.         END;
  117.       END;
  118.       array[Zaehler].while:=FALSE;
  119.       array[Zaehler].begin:=FALSE;
  120.       INC(Zaehler);
  121.       Korrekt:=TRUE;
  122.     END;
  123.  
  124.     IF (BefehlsListe[Zeiger] = "w") AND NOT(Korrekt) THEN
  125.       INC(Zeiger);
  126.       HoleSchleife(QuadListe[Zaehler].Befehl,BefehlsListe,Zeiger);
  127.       QuadListe[Zaehler].Zeile:=Zaehler;
  128.       QuadListe[Zaehler].IFzeile:=0;        (* Zaehler+1; *)
  129.       QuadListe[Zaehler].ELSEzeile:=0;      (* Zaehler+2; *)
  130.       array[Zaehler].whileZeiger:=Zaehler;
  131.       array[Zaehler].while:=TRUE;
  132.       array[Zaehler].begin:=FALSE;
  133.       INC(Zaehler);
  134.       Korrekt:=TRUE;
  135.     END;
  136.  
  137.     IF (BefehlsListe[Zeiger] = "e") AND NOT(Korrekt) THEN
  138.       IF begin > 1 THEN
  139.         Counter:=Zaehler-1;
  140.         WHILE NOT(array[Counter].begin) AND (Counter >= 1) DO
  141.           DEC(Counter);
  142.         END;
  143.         IF array[Counter].begin THEN
  144.           array[Counter].begin:=FALSE;
  145.           Counter2:=Counter+1;
  146.           WHILE (Counter2 < Zaehler)                      AND
  147.                 (QuadListe[Counter2].ELSEzeile # Zaehler) DO
  148.             INC(Counter2);
  149.           END;
  150.           IF (QuadListe[Counter2].ELSEzeile = Zaehler) AND
  151.              (array[Counter2].while) AND (Counter2 < Zaehler)  THEN
  152.             QuadListe[Counter2].ELSEzeile:=array[Counter].whileZeiger;
  153.           ELSE
  154.             QuadListe[Zaehler-1].IFzeile:=array[Counter].whileZeiger;
  155.             QuadListe[Zaehler-1].ELSEzeile:=array[Counter].whileZeiger;
  156.           END;
  157.           Counter2:=Counter-1;
  158.  
  159.           WHILE (Counter2 >= 1) AND (array[Counter2].while) AND
  160.                  NOT(array[Counter2].begin) DO
  161.             DEC(Counter2);
  162.           END;
  163.           INC(Counter2);
  164.           IF Counter2 >= 1 THEN
  165.             IF array[Counter2-1].while THEN
  166.               QuadListe[Counter2].ELSEzeile:=Counter2-1;
  167.             END;
  168.           END;
  169.           IF (array[Counter2].while) AND NOT(array[Counter2].begin) THEN
  170.             QuadListe[Counter2].ELSEzeile:=Zaehler;
  171.             QuadListe[Counter2].IFzeile:=Counter2+1;
  172.             INC(Counter2);
  173.             WHILE Counter2 <= Counter DO
  174.               QuadListe[Counter2].ELSEzeile:=Counter2-1;
  175.               QuadListe[Counter2].IFzeile:=Counter2+1;
  176.               INC(Counter2);
  177.             END;
  178.           END;
  179.         ELSE
  180.           WriteLn;
  181.           WriteString("Ein 'end' ohne 'begin' gefunden!!!");
  182.           WriteLn;
  183.           HALT;
  184.         END;
  185.       END;
  186.       DEC(begin);
  187.       INC(Zeiger);
  188.       IF BefehlsListe[Zeiger] = ";" THEN
  189.         INC(Zeiger);
  190.       END;
  191.       Korrekt:=TRUE;
  192.     END;
  193.  
  194.     IF NOT(Korrekt) THEN
  195.       WriteLn;
  196.       WriteString("Fehler!!! Keine korrekte Anweisung.");
  197.       WriteLn;
  198.       HALT;
  199.     END;
  200.  
  201.   UNTIL begin = 0;
  202.  
  203.   IF Zaehler > MaxQuad THEN
  204.     WriteLn;
  205.     WriteString("Erhoehe MaxQuad!!!");
  206.     WriteLn;
  207.     HALT;
  208.   ELSE
  209.     QuadListe[Zaehler].Zeile:=0;
  210.     QuadListe[Zaehler].IFzeile:=0;
  211.     QuadListe[Zaehler].ELSEzeile:=0;
  212.     QuadListe[Zaehler].Befehl:="";
  213.   END;
  214. END BerechneQuad;
  215.  
  216.  
  217. END QuadBerechneQuad.
  218.